import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

def createArray():
    """
    使用array、asarray创建数组
    :return:
    """
    # 根据给定维度创建数组；np.array默认情况下将会copy该对象，而asarray非必要不copy该对象
    arr011 = np.array([1, 2, 3], dtype=float)
    arr012 = np.array([[1, 2, 3], [1, 2, 3]], dtype=float)
    arr013 = np.asarray([1, 2, 3])
    arr014 = np.asarray([[1, 2, 3], [1, 2, 3]])

    print(arr011)
    print(arr012)
    print(arr013)
    print(arr014)


def createArrayByEmpty():
    """
    根据给定维度创建数组，数据不初始化
    :return:"""
    arr021 = np.empty([2])
    arr022 = np.empty([2, 3])
    arr023 = np.empty([2, 3, 4])

    print(arr021)
    print(arr022)
    print(arr023)


def createArrayByZeros():
    """
    根据给定维度创建数组，数据为0
    :return:"""

    arr031 = np.zeros(2)
    arr032 = np.zeros((3, 4))
    arr033 = np.zeros((2, 3, 4))

    print(arr031)
    print(arr032)
    print(arr033)


def createArrayByOnes():
    """
    根据给定维度创建数组，数据为1
    :return:"""

    arr041 = np.ones(2)
    arr042 = np.ones((3, 4))
    arr043 = np.ones((2, 3, 4))
    print(arr041)
    print(arr042)
    print(arr043)


def createArrayByFull():
    """
    根据给定维度创建数组, 数据指定（本例中为11）
    :return:"""

    arr051 = np.full(2, 11)
    arr052 = np.full((2, 3), 11)
    arr053 = np.full((2, 3, 4), 11)

    print(arr051)
    print(arr052)
    print(arr053)


def createArrayByarange():
    """
    在给定间隔内返回均匀间隔的值
    :return:"""

    # 在给定间隔内返回均匀间隔的值（间隔1）
    arr061 = np.arange(4, dtype=float)
    # 在给定间隔内返回均匀间隔的值（间隔20）
    arr062 = np.arange(0, 100, 20)

    print(arr061)
    print(arr062)


def createArrayByLinspace():
    """
    等差序列（默认为50）
    :return:"""

    arr071 = np.linspace(0, 10)
    arr072 = np.linspace(0, 10, 5)
    print(arr071)
    print(arr072)


def createArrayByRand():
    """
    根据给定维度，生成0~1随机数组
    :return:"""

    arr081 = np.random.rand(2)
    arr082 = np.random.rand(2, 3)
    arr083 = np.random.rand(2, 3, 4)

    # 根据给定维度：随机返回一个整数或数组
    arr084 = np.random.randint(5, 10)
    # 随机生成2以内二维数组
    arr085 = np.random.randint(5, size=(2, 3))
    arr086 = np.random.randint(0, 10, size=(2, 3))
    print(arr081)
    print(arr082)
    print(arr083)
    print(arr084)
    print(arr085)
    print(arr086)


def createArrayByRandn():
    """
    根据给定维度生成数组， 数据随机，并具有标准正态分布
    :return:"""
    arr091 = np.random.randn(2)
    arr092 = np.random.randn(2, 3)
    arr093 = np.random.randn(2, 3, 4)
    arr094 = np.random.randint(1, 3, 10)

    print(arr091)
    print(arr092)
    print(arr093)
    print(arr094)


def createArrayByNormal():
    """
     从正态（高斯）分布中抽取随机样本。
     棣莫佛第一次提出正态分布的概率密度函数（由于其外形形似铃铛，亦称为钟形曲线），
     在其后200年，高斯和拉普拉斯也分别发现了正态分布的概率密度函数。自然界中有许多符合正态分布的案例。
     例如，它可以描述样本受大量微小随机扰动影响的常见分布，其中，每个扰动都有自己独特的分布。

     loc	浮点型数据或者浮点型数据组成的数组
     scale	浮点型数据或者浮点型数据组成的数组
     size	整数或者整数组成的元组，可选参数

    :return:"""

    x = np.random.normal(10, 5, 1000)
    y = np.random.normal(10, 5, 1000)

    plt.scatter(x, y)
    plt.show()


def splicingByHVStack():
    """
    使用hstack、vstack堆叠数组数据
    :return:
    """
    arr_source_1 = np.array([[1, 2], [3, 4], [5, 6]])
    arr_source_2 = np.array([[11, 12], [13, 14], [15, 16]])

    # 按顺序水平方向堆叠数组
    hstack = np.hstack((arr_source_1, arr_source_2))

    # 按垂直水平方向堆叠数组
    vstack = np.vstack((arr_source_1, arr_source_2))

    print(hstack)
    print(vstack)


def splicingOneDimeSignByStack():
    """
    使用stack堆叠一维数组数据
    :return:
    """
    arr_source_1 = np.array([1, 2, 3, 4])
    arr_source_2 = np.array([11, 12, 13, 14])

    stack0 = np.stack((arr_source_1, arr_source_2), axis=0)
    stack1 = np.stack((arr_source_1, arr_source_2), axis=1)

    print(stack0)
    print(stack1)


def splicingTwoDimeSignByStack():
    """
    使用stack堆叠二维数组数据
    :return:
    """
    arr_source_1 = np.array([[1, 2], [3, 4], [5, 6]])
    arr_source_2 = np.array([[11, 12], [13, 14], [15, 16]])
    arr_source_3 = np.array([[21, 22], [23, 24], [25, 26]])

    stack0 = np.stack((arr_source_1, arr_source_2, arr_source_3), axis=0)
    stack1 = np.stack((arr_source_1, arr_source_2, arr_source_3), axis=1)
    stack2 = np.stack((arr_source_1, arr_source_2, arr_source_3), axis=2)

    print(stack0)
    print(stack1)
    print(stack2)


def updateTwoDimeSign():
    """
    通过索引修改二维数组
    :return:
    """
    source = np.array([[1, 2], [1, 2], [1, 2]])

    # 修改第一行
    source[0] = [11, 12]

    # 修改第2行第一列
    source[1][0] = 21

    print(source)


def updateOneDimeSign():
    """
    通过索引修改一维数组
    :return:
    """
    source = np.array([1, 2, 3, 4, 5, 6])

    # 修改第一行
    source[0] = 11

    print(source)


def findByWhere():
    """
    使用where过滤数据
    :return:
    """
    source = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

    # 过滤大于4的数据
    filter_arr1 = source[np.where(source > 4)]
    print("---------")
    print(filter_arr1)

    # 过滤大于4的数据并重新赋值
    filter_arr2 = np.array(np.where(source > 4, 1, 0))
    print(filter_arr2)


def sliceOneDimeSign():
    """
    切片一维数组
    :return:
    """
    source = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

    # 通过索引(0)查找第一个元素
    sliceFirst1 = source[0]
    sliceFirst2 = source[-10]

    # [-1] = 索引(N)查找最后一个元素
    sliceLast1 = source[9]
    sliceLast2 = source[-1]

    print(sliceFirst1)
    print(sliceFirst2)
    print(sliceLast1)
    print(sliceLast2)


def sliceOneDimeMult():
    """
    切片一维数组
    :return:
    """
    source = np.array([0, 11, 2, 13, 4, 5, 6, 7, 8, 9])

    # 索引(0~4）区间查找
    sliceArr11 = source[:5]
    sliceArr12 = source[0:5]
    sliceArr13 = source[-10:-5]

    # [2:] = 索引(2~N）区间查找
    sliceArr21 = source[2:]
    sliceArr22 = source[2:10]

    # [1:4] = 索引(1:3)区间查找
    sliceArr31 = source[1:4]
    sliceArr32 = source[-9:-6]

    # [:] = 索引(0~N）区间查找
    sliceArr41 = source[:]
    sliceArr42 = source[0:10]

    # [::2] = 索引(0, 2, 4,...），从索引0开始，步进为2
    sliceArr51 = source[::2]
    sliceArr52 = source[0:10:2]
    sliceArr53 = source[-10:-1:2]

    # [1::2] = 索引(1, 3, 5,...），从索引1开始，步进为2
    sliceArr61 = source[1::2]
    sliceArr62 = source[1:10:2]

    # [::-1] = 索引(N~1）区间查找， 即翻转
    sliceArr71 = source[::-1]

    # [:-5:-1] = 索引(N, N-4）区间查找， 即翻转，并查找最后4个元素
    sliceArr81 = source[:-5:-1]
    sliceArr82 = source[-1:-5:-1]
    sliceArr83 = source[10:5:-1]

    # [-3:-8:-2] = 索引(N-3, N-7）区间查找， 即翻转，并以步进为2查找元素
    sliceArr91 = source[-3:-8:-2]
    sliceArr92 = source[7:2:-2]

    # [-5::-2] = 索引(N-5, 0）区间查找， 即翻转，并以步进为2查找元素
    sliceArr101 = source[-5::-2]
    sliceArr102 = source[-5:-10:-2]
    sliceArr103 = source[5:0:-2]

    print(sliceArr11)
    print(sliceArr12)
    print(sliceArr13)
    print(sliceArr21)
    print(sliceArr22)
    print(sliceArr31)
    print(sliceArr31)
    print(sliceArr41)
    print(sliceArr42)
    print(sliceArr51)
    print(sliceArr52)
    print(sliceArr53)
    print(sliceArr61)
    print(sliceArr62)
    print(sliceArr71)
    print(sliceArr81)
    print(sliceArr82)
    print(sliceArr83)
    print(sliceArr91)
    print(sliceArr92)
    print(sliceArr101)
    print(sliceArr102)
    print(sliceArr103)


def sliceTwoDime():
    """
    切片二维数组
    :return:
    """
    data = [
        [10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
        [20, 21, 22, 23, 24, 25, 26, 27, 28, 29],
        [30, 31, 32, 33, 34, 35, 36, 37, 38, 39],
    ]
    source = np.array(data)

    # 获取第一行
    sliceArr11 = source[0]

    # 获取第一行第一列
    sliceArr12 = source[0][0]

    # 获取最后一行
    sliceArr13 = source[-1]

    # 获取第二行index0至index5数据
    sliceArr14 = source[1, :5]

    # 获取第1行至第2行,每行获取index3-index10
    sliceArr15 = source[:2, 3:]

    # 获取第1行至第2行,每行获取index0-index1
    sliceArr16 = source[:2, :2]

    # todo fsd 2 为什么只有一行数据
    sliceArr17 = source[:2, 2]

    # 获取每行，每行获取index0-index1
    sliceArr18 = source[:, :2]

    # 获取每行，每行获取index3-index6并且步进值为2
    sliceArr19 = source[:, 3:7:2]

    print("sliceArr11")
    print(sliceArr11)
    print("sliceArr12")
    print(sliceArr12)
    print("sliceArr13")
    print(sliceArr13)
    print("sliceArr14")
    print(sliceArr14)
    print("sliceArr15")
    print(sliceArr15)
    print("sliceArr16")
    print(sliceArr16)
    print("sliceArr17")
    print(sliceArr17)
    print("sliceArr18")
    print(sliceArr18)
    print("sliceArr19")
    print(sliceArr19)


def sliceThreeDime():
    """
    切片三维数组
    :return:
    """
    data = \
        [
            [
                [110, 111, 112, 113, 114, 115, 116],
                [120, 121, 122, 123, 124, 125, 126],
                [130, 121, 122, 123, 124, 125, 126],
                [140, 121, 122, 123, 124, 125, 126]
            ],
            [
                [210, 211, 212, 213, 214, 215, 216],
                [220, 221, 222, 223, 224, 225, 226],
                [230, 221, 222, 223, 224, 225, 226],
                [240, 221, 222, 223, 224, 225, 226]
            ],
            [
                [310, 311, 312, 313, 314, 315, 316],
                [320, 321, 322, 323, 324, 325, 326],
                [330, 321, 322, 323, 324, 325, 326],
                [340, 321, 322, 323, 324, 325, 326]
            ]
        ]

    source = np.array(data)

    print(source.shape)
    print(source[1:, 1:, 2:])


def delFun():
    """
    删除
    :return:
    """
    source = np.array([[1, 2, 3], [1, 2, 3], [1, 2, 3]])

    # 删除第三行
    del_arr_1 = source.copy()
    del_row = np.delete(del_arr_1, 2, axis=0)

    # 删除第二列
    del_arr_2 = source.copy()
    del_col = np.delete(del_arr_2, 1, axis=1)

    # 删除第二、三行
    del_arr_3 = source.copy()
    del_mult_row = np.delete(del_arr_3, (1, 2), axis=0)

    print(del_row)
    print(del_col)
    print(del_mult_row)


if __name__ == '__main__':
    # createArray()
    # createArrayByEmpty()
    # createArrayByZeros()
    # createArrayByOnes()
    # createArrayByFull()
    # createArrayByarange()
    # createArrayByLinspace()
    # createArrayByRand()
    # createArrayByRandn()
    createArrayByNormal()
    # showNpInfo()

    # *****************************

    # splicingByHVStack()
    # splicingOneDimeSignByStack()
    # splicingTwoDimeSignByStack()
    # updateOneDimeSign()
    # updateTwoDimeSign()

    # delFun()
    # findByWhere()
    # sliceOneDimeSign()
    # sliceOneDimeMult()
    # sliceTwoDime()
    # sliceThreeDime()
